home *** CD-ROM | disk | FTP | other *** search
/ Alles Voor Internet / Tout Pour Internet / alles voor internet.iso / MacInternet™ / Telnet / NCSA / tn3270 2.4d7 source / tn3270 / serscrn.c < prev    next >
Text File  |  1992-04-17  |  14KB  |  541 lines
  1. /*
  2.  *  tn3270 for the Macintosh Source Code
  3.  *  Brown University Computing and Information Services
  4.  *  Version 2.4d7  April, 1992
  5.  *  Copyright (c) 1988, 1989, 1990, 1991, 1992 by Brown University and by
  6.  *  Peter John DiCamillo.
  7.  *
  8.  *  Permission is granted to any individual or institution to use, copy,
  9.  *  or redistribute the binary version of this software and its
  10.  *  documentation provided this notice and the copyright notices are
  11.  *  retained.  Permission is granted to any individual or non-profit
  12.  *  institution to use, copy, modify, or redistribute the source files
  13.  *  of this software provided this notice and the copyright notices are
  14.  *  retained.  This software may not be distributed for profit, either
  15.  *  in original form or in derivative works, nor can the source be
  16.  *  distributed to other than an individual or a non-profit institution.
  17.  *  Any  individual or group interested in seeing and/or using these
  18.  *  source files but who are prevented from doing so by the above
  19.  *  constraints should contact Don Wolfe, Assistant Vice-President for
  20.  *  Computer Systems at Brown University, (401) 863-7250, for possible
  21.  *  software licensing of the source developed at Brown.
  22.  *
  23.  *  Brown University and Peter John DiCamillo make no representations
  24.  *  about the suitability of this software for any purpose.
  25.  *
  26.  *  BROWN UNIVERSITY AND PETER JOHN DICAMILLO GIVE NO WARRANTY, EITHER
  27.  *  EXPRESS OR IMPLIED, FOR THE PROGRAM AND/OR DOCUMENTATION PROVIDED,
  28.  *  INCLUDING, WITHOUT LIMITATION, WARRANTY OF MERCHANTABILITY AND
  29.  *  WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE.
  30.  *
  31.  */
  32.  
  33. #if !defined(USEDUMP)
  34.     #include "maclib.h"
  35.     #include "termdef.h"
  36.     #include "tn3270funcs.h"
  37.     #include "globals.h"
  38. #else
  39.     #pragma load "tn3270DumpFile"
  40. #endif
  41.  
  42. #pragma segment 3270seg3
  43.  
  44. extern RGBColor realwhite;
  45.  
  46. unsigned char cptoebc[] = {
  47.     0x00,0x01,0x02,0x03,0x37,0x2d,0x2e,0x2f,
  48.     0x16,0x05,0x25,0x0b,0x0c,0x0d,0x0e,0x0f,
  49.     0x10,0x11,0x12,0x3b,0x3c,0x3d,0x32,0x26,
  50.     0x18,0x19,0x3f,0x27,0x1c,0x1d,0x1e,0x1f,
  51.     0x40,0x5a,0x7f,0x7b,0x5b,0x6c,0x50,0x7d,
  52.     0x4d,0x5d,0x5c,0x4e,0x6b,0x60,0x4b,0x61,
  53.     0xf0,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,
  54.     0xf8,0xf9,0x7a,0x5e,0x4c,0x7e,0x6e,0x6f,
  55.     0x7c,0xc1,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
  56.     0xc8,0xc9,0xd1,0xd2,0xd3,0xd4,0xd5,0xd6,
  57.     0xd7,0xd8,0xd9,0xe2,0xe3,0xe4,0xe5,0xe6,
  58.     0xe7,0xe8,0xe9,0xad,0xe0,0xbd,0x5f,0x6d,
  59.     0x79,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
  60.     0x88,0x89,0x91,0x92,0x93,0x94,0x95,0x96,
  61.     0x97,0x98,0x99,0xa2,0xa3,0xa4,0xa5,0xa6,
  62.     0xa7,0xa8,0xa9,0xc0,0x4f,0xd0,0xa1,0x07};
  63.  
  64. void putscr(unsigned char *s, short slen, char wr, cnr *cp)
  65. {
  66. static unsigned char idstr[] = {0x1b, 0x2f, 0x5a};
  67. register unsigned char a, c;
  68. register short count;
  69. short i, m, newadr;
  70. char writeflg;
  71. unsigned char saverow;
  72.  
  73. if (slen == 0) return;
  74. writeflg = 0;
  75. newadr = cp->curadr;
  76. for (count=0; count < slen; count++) {
  77.     a = s[count];
  78.     if (wr) serout(a);
  79.     c = cptoebc[a & 0x7f];
  80.     switch(cp->escmode) {
  81.         case 0:                /* no preceding ESC */
  82.             if (c >= 0x40) cp->skiplf = 0;
  83.             switch(c) {
  84.                 case 0x2f:                /* bell (07) */
  85.                     cp->pndbeep = 1;
  86.                     break;
  87.                 case 0x16:                /* backspace (08) */
  88.                     if (newadr == 0) newadr = cp->maxoff;
  89.                     else newadr--;
  90.                     break;
  91.                 case 0x05:                /* horizontal tab (09) */
  92.                     newadr >> 2;
  93.                     newadr += 1;
  94.                     newadr << 2;
  95.                     if (newadr > cp->maxoff) newadr = 0;
  96.                     break;
  97.                 case 0x25:                /* line feed (0A) */
  98.                     if (cp->skiplf) {
  99.                         cp->skiplf = 0;
  100.                         break;
  101.                         }
  102.                     newadr = (newadr/cp->scrhsize) * cp->scrhsize;
  103.                     m = cp->maxoff/cp->scrhsize;
  104.                     i = newadr/cp->scrhsize;
  105.                     if (i < m) newadr += cp->scrhsize;
  106.                     else {
  107.                         scrollscrn(cp);
  108.                         writeflg = 0;
  109.                         }
  110.                     break;
  111.                 case 0x0b:                /* vertical tab (0B) */
  112.                     newadr += cp->scrhsize;
  113.                     if (newadr > cp->maxoff) newadr -= cp->maxcnt;
  114.                     break;
  115.                 case 0x0c:                /* form feed (0C) */
  116.                     clrscn(cp);
  117.                     invldscr(cp);
  118.                     newadr = 0;
  119.                     break;
  120.                 case 0x0d:                /* carriage return (0D) */
  121.                     newadr = (newadr/cp->scrhsize) * cp->scrhsize;
  122.                     break;
  123.                 case 0x27:                /* ESC */
  124.                     cp->escmode = 1;
  125.                 default:
  126.                     if (c < 0x40) break;    /* ignore other control chars. */
  127.                                         /* data character */
  128.                     if ((c == 0xad) || (c == 0xbd)) {
  129.                         newchar(newadr, c, 0x4000, 0, cp);
  130.                         }
  131.                     else {
  132.                         newchar(newadr, c, 0, 0, cp);
  133.                         }
  134.                     writeflg = 1;
  135.                     newadr++;
  136.                     if ((newadr%cp->scrhsize) == 0) cp->skiplf = 1;
  137.                     if (newadr == cp->maxcnt) {
  138.                         newadr = (cp->maxoff/cp->scrhsize) * cp->scrhsize;
  139.                         scrollscrn(cp);
  140.                         writeflg = 0;
  141.                         }
  142.                     break;
  143.                 }
  144.             break;
  145.         case 1:            /* first char. after ESC */
  146.             switch(c) {
  147.                 case 0xc1:        /* A - up */
  148.                     if ((newadr-cp->scrhsize) >= 0) newadr -= cp->scrhsize;
  149.                     cp->escmode = 0;
  150.                     break;
  151.                 case 0xc2:        /* B - down */
  152.                     if ((newadr+cp->scrhsize) < cp->maxcnt) newadr += cp->scrhsize;
  153.                     cp->escmode = 0;
  154.                     break;
  155.                 case 0xc3:        /* C - right */
  156.                     if ((newadr+1) < cp->maxcnt) newadr++;
  157.                     cp->escmode = 0;
  158.                     break;
  159.                 case 0xc4:        /* D - left */
  160.                     if ((newadr-1) >= 0) newadr--;
  161.                     cp->escmode = 0;
  162.                     break;
  163.                 case 0xc8:        /* H - cursor home */
  164.                     newadr = 0;
  165.                     cp->escmode = 0;
  166.                     break;
  167.                 case 0xc9:        /* I - reverse line feed */
  168.                     if (newadr > cp->scrhoff) newadr -= cp->scrhsize;
  169.                     else {
  170.                         revscroll(cp);
  171.                         writeflg = 0;
  172.                         }
  173.                     cp->escmode = 0;
  174.                     break;
  175.                 case 0xd1:        /* J - erase to end of screen */
  176.                     i = newadr;
  177.                     newchar(i, 0, 0, 0, cp);
  178.                     i++;
  179.                     while (i < cp->maxcnt) {
  180.                         newchar(i, 0, 0, 0, cp);
  181.                         i++;
  182.                         }
  183.                     writeflg = 1;
  184.                     cp->escmode = 0;
  185.                     break;
  186.                 case 0xd2:        /* K - erase to end of line */
  187.                     i = newadr;
  188.                     newchar(i, 0, 0, 0, cp);
  189.                     i++;
  190.                     while ((i < cp->maxcnt) && ((i%cp->scrhsize) != 0)) {
  191.                         newchar(i, 0, 0, 0, cp);
  192.                         i++;
  193.                         }
  194.                     writeflg = 1;
  195.                     cp->escmode = 0;
  196.                     break;
  197.                 case 0xe8:        /* Y - start of cursor address */
  198.                     cp->escmode = 2;
  199.                     break;
  200.                 case 0xe9:        /* Z - return my terminal type */
  201.                     if (cp->tcpflg) {
  202.                         tcpwrite(idstr, 3, cp);
  203.                         }
  204.                     else if (cp->serflg) {
  205.                         serout(idstr[0]);
  206.                         serout(idstr[1]);
  207.                         serout(idstr[2]);
  208.                         }
  209.                     cp->escmode = 0;
  210.                     break;
  211.                 default:
  212.                     cp->escmode = 0;
  213.                     break;
  214.                 }
  215.             break;
  216.         case 2:            /* second char. after ESC */
  217.             saverow = a;
  218.             cp->escmode = 3;
  219.             break;
  220.         case 3:            /* third char. after ESC */
  221.             newadr = (saverow - 0x20) * cp->scrhsize + a - 0x20;
  222.             if (newadr < 0) newadr = 0;
  223.             if (newadr > cp->maxoff) newadr = cp->maxoff;
  224.             cp->escmode = 0;
  225.             break;
  226.         default:
  227.             break;
  228.         }
  229.     }
  230. if (writeflg) newwrite(cp);
  231. if (cp->curadr != newadr) {
  232.     cp->curadr = newadr;
  233.     newcur(cp);
  234.     }
  235. }
  236.  
  237. void scrollscrn(cnr *cp)
  238. {
  239. register short i, n;
  240. unsigned char * cptr;
  241. unsigned short * iptr;
  242.  
  243. /* update character and attribute buffers */
  244. n = cp->maxcnt/cp->scrhsize - 1;
  245. cptr = cp->chrbuff;
  246. iptr = cp->atrbuff;
  247. for (i=0; i < n; i++) {
  248.     memcpy(cptr, cptr+cp->scrhsize, cp->scrhsize);
  249.     memcpy(iptr, iptr+cp->scrhsize, cp->scrhsize<<1);
  250.     cptr += cp->scrhsize;
  251.     iptr += cp->scrhsize;
  252.     }
  253. memset(cptr, 0, cp->scrhsize);
  254. memset(iptr, 0, cp->scrhsize<<1);
  255.  
  256. /* prevent drawing of saved input */
  257. cp->in_len = 0;
  258. cp->inrect.top = cp->inrect.left = 32767;
  259. cp->inrect.bottom = cp->inrect.right = -32767;
  260.  
  261. /* update bitmap or screen */
  262. invldscr(cp);
  263. }
  264.  
  265. void revscroll(cnr *cp)
  266. {
  267. register short i, n;
  268. unsigned char * cptr;
  269. unsigned short * iptr;
  270.  
  271. /* update character and attribute buffers */
  272. n = cp->maxcnt/cp->scrhsize - 1;
  273. cptr = cp->chrbuff + cp->maxcnt - cp->scrhsize;
  274. iptr = cp->atrbuff + cp->maxcnt - cp->scrhsize;
  275. for (i=0; i < n; i++) {
  276.     memcpy(cptr, cptr-cp->scrhsize, cp->scrhsize);
  277.     memcpy(iptr, iptr-cp->scrhsize, cp->scrhsize<<1);
  278.     cptr -= cp->scrhsize;
  279.     iptr -= cp->scrhsize;
  280.     }
  281. memset(cptr, 0, cp->scrhsize);
  282. memset(iptr, 0, cp->scrhsize<<1);
  283.  
  284. /* prevent drawing of saved input */
  285. cp->in_len = 0;
  286. cp->inrect.top = cp->inrect.left = 32767;
  287. cp->inrect.bottom = cp->inrect.right = -32767;
  288.  
  289. /* update bitmap or screen */
  290. invldscr(cp);
  291. }
  292.  
  293. void putsrv(unsigned char *s, short slen, char inp, cnr *cp)
  294. {
  295. register unsigned char a, c;
  296. short count, i, len, newadr, startadr;
  297. char writeflg;
  298. unsigned char *cptr;
  299.  
  300. if (slen == 0) return;
  301. writeflg = 0;
  302. newadr = cp->curadr;
  303. startadr = cp->maxcnt - cp->scrhsize * 2;
  304. for (count=0; count < slen; count++) {
  305.     a = s[count];
  306.     c = cptoebc[a & 0x7f];
  307.     if (!inp) {
  308.         srvnewchar(c, cp);
  309.         continue;
  310.         }
  311.     switch(c) {
  312.         case 0x16:                /* backspace (08) */
  313.             if (newadr == startadr) break;
  314.             newadr--;
  315.             newchar(newadr, 0, 0, 0, cp);
  316.             writeflg = 1;
  317.             break;
  318.         case 0x0d:                /* carriage return (0D) */
  319.             cptr = cp->chrbuff + cp->maxoff;
  320.             for (i = cp->scrhsize*2; i > 0; i--) {
  321.                 a = *(cptr--);
  322.                 if ((a != 0) && (a != 0x40)) break;
  323.                 }
  324.             len = i;
  325.             newadr = startadr;
  326.             if (len == 0) break;
  327.             if (cp->serflg) {
  328.                 cp->respflag = 1;
  329.                 cptr = cp->chrbuff + startadr;
  330.                 for (i = 0; i < len; i++) {
  331.                     serout(((*xtabh)[cptr[i]]) & 0x7f);
  332.                     }
  333.                 serout(0x0d);
  334.                 }
  335.             else {
  336.                 srvtext(cp->chrbuff + startadr, cp->atrbuff + startadr, len, cp);
  337.                 cptr = cp->chrbuff + startadr;
  338.                 for (i = 0; i < len; i++) {
  339.                     cptr[i] = (*xtabh)[cptr[i]];
  340.                     }
  341.                 cptr[len++] = 0x0d;
  342.                 cptr[len++] = 0x0a;
  343.                 tcpwrite(cptr, len, cp);
  344.                 }
  345.             memset(cp->chrbuff + startadr, 0, cp->scrhsize*2);
  346.             memset(cp->atrbuff + startadr, 0, cp->scrhsize*4);
  347.  
  348.             /* prevent drawing of saved input */
  349.             cp->in_len = 0;
  350.             cp->inrect.top = cp->inrect.left = 32767;
  351.             cp->inrect.bottom = cp->inrect.right = -32767;
  352.  
  353.             /* update bitmap or screen */
  354.             invldscr(cp);
  355.             break;
  356.         default:
  357.             if (c < 0x40) break;    /* ignore other control chars. */
  358.                                 /* data character */
  359.             if (newadr == cp->maxoff) {
  360.                 beep(cp);
  361.                 break;
  362.                 }
  363.             if ((c == 0xad) || (c == 0xbd)) newchar(newadr, c, 0x4006, 6, cp);
  364.             else newchar(newadr, c, 6, 6, cp);
  365.             writeflg = 1;
  366.             newadr++;
  367.             break;
  368.         }
  369.     }
  370. if (writeflg) newwrite(cp);
  371. if (cp->curadr != newadr) {
  372.     cp->curadr = newadr;
  373.     newcur(cp);
  374.     }
  375. }
  376.  
  377. void srvnewchar(unsigned char c, cnr *cp)
  378. {
  379. int rc;
  380.  
  381. switch(c) {
  382.     case 0x25:
  383.                 rc = srvproc(cp->linetext, cp->lineattr, cp->linelen, cp);
  384.                 if (rc == 0) srvtext(cp->linetext, cp->lineattr, cp->linelen, cp);
  385.                 cp->linelen = 0;                
  386.                 break;
  387.     default:
  388.                 if (c < 0x40) break;
  389.                 if (cp->linelen == 512) break;
  390.                 (cp->linetext)[cp->linelen] = c;
  391.                 if ((c == 0xad) || (c == 0xbd)) (cp->lineattr)[cp->linelen++] = 0x4000;
  392.                 else (cp->lineattr)[cp->linelen++] = 0;
  393.                 break;
  394.     }
  395. }
  396.  
  397. void srvtext(unsigned char *text, unsigned short *attr, short len, cnr *cp)
  398. {
  399. short i, linecount, scrollcount;
  400.  
  401. if (len == 0) return;
  402. linecount = (len + cp->scrhsize - 1)/cp->scrhsize;
  403. scrollcount = linecount - (cp->maxcnt - cp->scrhsize*2 - cp->msgoffset)/cp->scrhsize;
  404. if (scrollcount > 0) {
  405.     for (i = 0; i < scrollcount; i++) {
  406.         srvscroll(cp);
  407.         cp->msgoffset -= cp->scrhsize;
  408.         }
  409.     }
  410. if (((attr[0] & 0x07) == 6) || cp->respflag) {
  411.     for (i = 0; i < len; i++) {
  412.         attr[i] &= 0xFFF8;
  413.         attr[i] |= 5;
  414.         }
  415.     cp->respflag = 0;
  416.     }
  417. memcpy(cp->chrbuff+cp->msgoffset, text, len);
  418. memcpy(cp->atrbuff+cp->msgoffset, attr, len<<1);
  419. cp->msgoffset += linecount*cp->scrhsize;
  420.  
  421. /* prevent drawing of saved input */
  422. cp->in_len = 0;
  423. cp->inrect.top = cp->inrect.left = 32767;
  424. cp->inrect.bottom = cp->inrect.right = -32767;
  425.  
  426. /* update bitmap or screen */
  427. invldscr(cp);
  428. }
  429.  
  430. int srvproc(unsigned char *text, unsigned short *attr, short len, cnr *cp)
  431. {
  432. short i;
  433. unsigned char *irchost;
  434. short ircsize;
  435.  
  436. if (len == 0) return(0);
  437. if (cp->serverflags == 0) return(0);
  438.  
  439. memcpy(cp->proctext, text, len);
  440. memcpy(cp->procattr, attr, len<<1);
  441.  
  442. /* IRC processing */
  443. if (len < 5) return(0);
  444. for (i = 0; i < 5; i++) {
  445.     (cp->proctext)[i] = (*xtabh)[(cp->proctext)[i]];
  446.     }
  447. (cp->proctext)[5] = 0;
  448. if (strcmp(cp->proctext, "PING ") == 0) {
  449.     if (cp->hostok == 0) {
  450.         cp->hostok = 1;
  451.         strcpy(cp->prochost, "PONG ");
  452.         irchost = cp->connhostname;
  453.         while ((*irchost != '\0') && (*irchost != ':')) irchost++;
  454.         ircsize = 0;
  455.         if (*irchost == ':') {
  456.             irchost++;
  457.             while ((irchost[ircsize] != '\0') &&
  458.                    (irchost[ircsize] != ':')) ircsize++;
  459.             }
  460.         if (ircsize > 0) {
  461.             for (i=0; i < ircsize; i++) {
  462.                 (cp->prochost)[i+5] = tolower(irchost[i]);
  463.                 }
  464.             (cp->prochost)[ircsize+5] = 0;
  465.             }
  466.         else (cp->prochost)[4] = 0;
  467.         i = strlen(cp->prochost);
  468.         if (cp->serflg) {
  469.             (cp->prochost)[i] = 0x0d;
  470.             }
  471.         else {
  472.             (cp->prochost)[i++] = 0x0d;
  473.             (cp->prochost)[i] = 0x0a;
  474.             }
  475.         }
  476.     if (cp->serflg) {
  477.         i = 0;
  478.         while ((cp->prochost)[i] != 0) {
  479.             serout((cp->prochost)[i++]);
  480.             }
  481.         cp->respflag = 1;
  482.         return(1);
  483.         }
  484.     else {
  485.         tcpwrite(cp->prochost, strlen(cp->prochost), cp);
  486.         return(0);
  487.         }
  488.     }
  489. return(0);
  490. }
  491.  
  492. void srvscroll(cnr *cp)
  493. {
  494. register short i, n;
  495. unsigned char * cptr;
  496. unsigned short * iptr;
  497.  
  498. /* update character and attribute buffers */
  499. n = cp->maxcnt/cp->scrhsize - 1;
  500. n -= 2;
  501. cptr = cp->chrbuff;
  502. iptr = cp->atrbuff;
  503. for (i=0; i < n; i++) {
  504.     memcpy(cptr, cptr+cp->scrhsize, cp->scrhsize);
  505.     memcpy(iptr, iptr+cp->scrhsize, cp->scrhsize<<1);
  506.     cptr += cp->scrhsize;
  507.     iptr += cp->scrhsize;
  508.     }
  509. memset(cptr, 0, cp->scrhsize);
  510. memset(iptr, 0, cp->scrhsize<<1);
  511. }
  512.  
  513. void srvswitch(cnr *cp)
  514. {
  515. cp->servermode ^= 1;
  516. if (cp->servermode) {
  517.     cp->curadr = cp->maxcnt - cp->scrhsize*2;
  518.     cp->msgoffset = 0;
  519.     cp->linelen = 0;
  520.     cp->linetext = cp->readbuff;
  521.     cp->lineattr = (unsigned short *)(cp->linetext + 512);
  522.     cp->proctext = cp->linetext + 1536;
  523.     cp->procattr = (unsigned short *)(cp->linetext + 2048);
  524.     cp->prochost = cp->linetext + 3072;
  525.     cp->respflag = 0;
  526.     }
  527. else {
  528.     cp->curadr = 0;
  529.     }
  530. memset(cp->chrbuff, 0, cp->maxcnt);
  531. memset(cp->atrbuff, 0, cp->maxcnt<<1);
  532. /* prevent drawing of saved input */
  533. cp->in_len = 0;
  534. cp->inrect.top = cp->inrect.left = 32767;
  535. cp->inrect.bottom = cp->inrect.right = -32767;
  536.  
  537. /* update bitmap or screen */
  538. invldscr(cp);
  539. newcur(cp);
  540. }
  541.